<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C<C

The style of code in H3sm is weird enough that I thought maybe I should
call it something. Here's an IRC log on the subject...

<colorg> My 3-stacker is in what I call C--    more un-C-like C than GForth.
<eihrul> there's already a C--
<colorg> bummer.
<Downix> What about a C==?
<colorg> what about C- ?
<Fare> C==? ain't that a Commodore logo?
<colorg> C=
<Downix> C= is
* colorg salutes the C=
<Fare> what about C<< ?
<colorg> wagnificent, C<<
<colorg> s/wag/mag    wagnificent too, actually
<eihrul> wagnificent works
<eihrul> as the << is a tail
<colorg> aye, and "C left-shift" is a bit waggish


Well, at the moment I think "<C", pronounced "less-than C", is better. 

What is <C? Well, currently,
it is...
	an idiom of C used for it's portability only, but not for it's fancier 
		features, i.e. maximizing C/as as a portable assembler.
	GNU C and GNU assembler directives in asm escapes.
	libc-less, syscalls only for host services.
	portable, except for opcodes in syscalls and argv/envp handling.
	function-less. It's all in main() or _start()
	liberal use of casts and unions.
	dependant on GNU C extensions labels-as-values, computed-goto, and
		generalized lvalues, particularly lvalues with casts.
	minimal pointer declarations. Pointer ops on ints with casts.
		H3sm e.g. declares one pointer, ip, needed for gcc computed goto.
	minimal array ops. Ops on ints containing addresses of  arrays, i.e. array 
		declarations themselves are just space allocators.
	directives-only asm constructs in the C to intersperse data with code
		(muchly needed and a huge win for threaded code, e.g. a Forth.)
	the previous item may require another preprocessor in addition to
		cpp for .ascii directives. I use m4. This would be the only way
		it's more than C.
	make-less. unix shells have the -nt test since Korn, which isn't
		useful with e.g. H3sm anyway since it builds in 9 seconds on
		a 486.
	limited macro or typedef renaming of C keywords, char -> byte, etc.
	sourcecode for a program contained in as few files as practical
	considering compiler warnings as merely kibbitzing.
	largely unoptimizable. Many optimizations are function-call related.
		We fixed that already :o)
	how a Forth guy would re-write or de-write C.
	C with it's safety equipment removed.
	clearer, in my opinion. 
	Turing-complete and not inately performance-damaging.
	of use for writing something that is intended to be very un-C-like.
	a loose collection of related techniques
		


It isn't...
	a distinct programming language
	useful for large existing projects.
	
Here's an example of what the "no pointer declarations" bit is based on...

..............................................................................
/*  nonpointers.c 	*/
char 		main(){

int r, i, p1, p2 , p3 ;

char * a[100]= { 
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7 ,  
0, 1, 2, 3 , 4 , 5 , 6 , 7  }
;

char * b[100];
*a = 7 ;
p1 = (int)&a;
p2 = (int)&b;
printf(" %u \n", p1 );

for ( i = 100 ; i ; i--)
	{ *(char *)(p2+i) = *(char *)(p1+i);	/* here we use a moving address 
						as a storage location. 
						an lvalue. */

	printf (" %u \n ", *(char *)(p2+i));	/* here we de-reference an int. 
					this means we can do pointers with just 
					casts. I can't get this to happen without
					a memory store with declared pointers.
					I have since been told it's possible, but
					the guy sent no code, and what he said 
					in the IRC channel was hideous, even if it
					does work.
					*/
	}
return r;
}

............................................................................

I have retro-fitted H3sm with the pointer stack as a cell stack, an array
	of ints. I haven't removed all array indexing ops. 

